// -*- coding: utf-8 -*-
/*
author: zengbin93
email: zeng_bin8888@163.com
create_dt: 2022/12/16 19:37
describe: SVC模块的基础功能模块
*/

use chrono::{DateTime, Utc};
use serde_json::Value;
use std::collections::HashMap;

/// 数据类型枚举
#[derive(Debug, Clone, PartialEq)]
pub enum DataType {
    String,
    Number,
    Boolean,
    DateTime,
    Array,
    Object,
}

/// 数据列信息
#[derive(Debug, Clone)]
pub struct ColumnInfo {
    pub name: String,
    pub data_type: DataType,
    pub nullable: bool,
}

/// 数据表结构
#[derive(Debug, Clone)]
pub struct DataFrame {
    pub columns: Vec<ColumnInfo>,
    pub data: Vec<HashMap<String, Value>>,
}

impl DataFrame {
    /// 创建新的DataFrame
    pub fn new() -> Self {
        Self {
            columns: Vec::new(),
            data: Vec::new(),
        }
    }
    
    /// 添加列
    pub fn add_column(&mut self, name: &str, data_type: DataType, nullable: bool) {
        self.columns.push(ColumnInfo {
            name: name.to_string(),
            data_type,
            nullable,
        });
    }
    
    /// 添加行数据
    pub fn add_row(&mut self, row: HashMap<String, Value>) {
        self.data.push(row);
    }
    
    /// 获取行数
    pub fn len(&self) -> usize {
        self.data.len()
    }
    
    /// 检查是否为空
    pub fn is_empty(&self) -> bool {
        self.data.is_empty()
    }
    
    /// 获取列名列表
    pub fn get_column_names(&self) -> Vec<String> {
        self.columns.iter().map(|col| col.name.clone()).collect()
    }
    
    /// 获取指定列的数据
    pub fn get_column(&self, column_name: &str) -> Vec<Value> {
        self.data
            .iter()
            .map(|row| row.get(column_name).cloned().unwrap_or(Value::Null))
            .collect()
    }
    
    /// 过滤数据
    pub fn filter<F>(&self, predicate: F) -> DataFrame 
    where
        F: Fn(&HashMap<String, Value>) -> bool,
    {
        let mut filtered = DataFrame::new();
        filtered.columns = self.columns.clone();
        filtered.data = self.data.iter().filter(|row| predicate(row)).cloned().collect();
        filtered
    }
    
    /// 排序数据
    pub fn sort_by<F>(&mut self, column: &str, comparator: F)
    where
        F: Fn(&Value, &Value) -> std::cmp::Ordering,
    {
        self.data.sort_by(|a, b| {
            let a_val = a.get(column).unwrap_or(&Value::Null);
            let b_val = b.get(column).unwrap_or(&Value::Null);
            comparator(a_val, b_val)
        });
    }
}

/// 样式配置
#[derive(Debug, Clone)]
pub struct StyleConfig {
    pub positive_indicators: Vec<String>,
    pub negative_indicators: Vec<String>,
    pub neutral_indicators: Vec<String>,
}

impl Default for StyleConfig {
    fn default() -> Self {
        Self {
            positive_indicators: vec![
                "绝对收益".to_string(),
                "年化".to_string(),
                "夏普".to_string(),
                "卡玛".to_string(),
                "日胜率".to_string(),
                "日盈亏比".to_string(),
                "日赢面".to_string(),
                "非零覆盖".to_string(),
                "新高占比".to_string(),
                "单笔收益".to_string(),
                "回归年度回报率".to_string(),
                "交易胜率".to_string(),
                "持仓K线数".to_string(),
                "与基准相关性".to_string(),
                "与基准波动相关性".to_string(),
            ],
            negative_indicators: vec![
                "最大回撤".to_string(),
                "年化波动率".to_string(),
                "下行波动率".to_string(),
                "盈亏平衡点".to_string(),
                "新高间隔".to_string(),
                "回撤风险".to_string(),
                "波动比".to_string(),
            ],
            neutral_indicators: vec![
                "基准年化".to_string(),
                "基准夏普".to_string(),
                "基准最大回撤".to_string(),
                "基准年化波动率".to_string(),
            ],
        }
    }
}

/// 应用样式配置
pub fn apply_stats_style(df: &DataFrame, config: &StyleConfig) -> DataFrame {
    // 在Rust中，我们返回一个新的DataFrame，包含样式信息
    // 实际的样式应用需要在UI层面处理
    df.clone()
}

/// 确保日期时间索引
pub fn ensure_datetime_index(df: &mut DataFrame, dt_col: &str) -> Result<(), Box<dyn std::error::Error>> {
    // 检查是否存在日期时间列
    if !df.get_column_names().contains(&dt_col.to_string()) {
        return Err("指定的日期时间列不存在".into());
    }
    
    // 验证日期时间格式
    for row in &df.data {
        if let Some(dt_value) = row.get(dt_col) {
            if dt_value.is_string() {
                // 尝试解析日期时间字符串
                if let Ok(_) = DateTime::parse_from_rfc3339(dt_value.as_str().unwrap()) {
                    // 日期时间格式正确
                } else {
                    return Err("日期时间格式不正确".into());
                }
            } else if !dt_value.is_null() {
                return Err("日期时间列必须是字符串格式".into());
            }
        }
    }
    
    Ok(())
}

/// 安全导入函数（Rust版本中主要用于兼容性）
pub fn safe_import_daily_performance() -> Option<fn() -> DataFrame> {
    // 在Rust中，我们直接返回None，因为需要重新实现
    None
}

/// 安全导入WeightBacktest类
pub fn safe_import_weight_backtest() -> Option<fn() -> ()> {
    // 在Rust中，我们直接返回None，因为需要重新实现
    None
}

/// 安全导入top_drawdowns函数
pub fn safe_import_top_drawdowns() -> Option<fn(&DataFrame) -> DataFrame> {
    // 在Rust中，我们直接返回None，因为需要重新实现
    None
} 